package api_vsys

import (
	"fmt"
	"restapi/config"
	"restapi/data"
	"restapi/module"
	"strconv"
	"time"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

// 统一日期格式 (年-月-日 时-分-秒)
const dateLayout = "2006-01-02 15:04:05"

// 创建虚拟系统
func Create_Vsys(g *gin.Context) {
	logrus.Info("Create_Vsys开始处理请求.....")
	var req module.CreateVsysRequest
	if !decodeJSON(g, &req) {
		return
	}
	// 业务逻辑 - 校验必填字段
	if ok, msg := validateCreateVsys(&req); !ok {
		respond400(g, msg)
		return
	}
	//检查name字段长度
	MAXEN := config.C.Limits.NameMaxLen // 若 VSYS 名称长度需区分，可在配置中单独加字段
	if len(req.Name) > MAXEN {
		g.JSON(400, module.CreateVsysResponse{
			Code:    400,
			Message: fmt.Sprintf("虚拟系统名称长度超过%d字符", MAXEN),
		})
		return
	}
	//检查数量上限
	MAXSIZE := config.C.Limits.VsysMaxNum
	vsysList, _, err := data.ListVsys(100, 1, "")
	if err != nil {
		g.JSON(500, module.CreateVsysResponse{
			Code:    500,
			Message: "查询现有虚拟系统时出现错误",
		})
		return
	}
	logrus.Infof("当前已有虚拟系统数量: %d", len(vsysList))
	if len(vsysList) >= MAXSIZE {
		g.JSON(400, module.CreateVsysResponse{
			Code:    400,
			Message: fmt.Sprintf("虚拟系统数量已达上限(%d个)", MAXSIZE),
		})
		return
	}
	//先检查名字是否重复
	if result, err := data.IsVsysNameConflict(req.Name); err != nil || result { //判断名字是否重复
		g.JSON(400, module.CreateVsysResponse{
			Code:    400,
			Message: fmt.Sprintf("虚拟系统(%v)已经存在", req.Name),
		})
		return
	} else {
		vsys := data.Vsys{
			Name:        req.Name,
			Description: req.Description,
			Interfaces:  req.Interfaces,
			CreatedAt:   time.Now(),
			UpdatedAt:   time.Now(),
		}
		if err := data.CreateVsys(&vsys); err != nil {
			g.JSON(500, module.CreateVsysResponse{
				Code:    500,
				Message: "创建操作执行失败",
			})
			return
		}
	}

	g.JSON(200, module.CreateVsysResponse{
		Code:    200,
		Message: "创建成功",
	})
}

// 删除虚拟系统
func Delete_Vsys(g *gin.Context) {
	logrus.Info("Delete_Vsys开始处理请求.....")
	var req module.DeleteVsysRequest
	if !decodeJSON(g, &req) {
		return
	}
	// 业务逻辑 - 校验
	if ok, msg := validateDeleteVsys(&req); !ok {
		respond400(g, msg)
		return
	}
	for _, id := range req.Id {
		//先查询虚拟系统是否存在
		p, err := data.GetVsysByID(id)
		if err != nil || p == nil {
			g.JSON(400, module.DeleteVsysResponse{
				Code:    400,
				Message: fmt.Sprintf("没有ID为%d的虚拟系统", id),
			})
			return
		}
		//执行删除操作
		if err := data.DeleteVsys(id); err != nil {
			g.JSON(500, module.DeleteVsysResponse{
				Code:    500,
				Message: "删除操作执行失败",
			})
			return
		}
	}
	g.JSON(200, module.DeleteVsysResponse{
		Code:    200,
		Message: "删除成功",
	})
}

// 编辑虚拟系统
func Update_Vsys(g *gin.Context) {
	logrus.Info("Update_Vsys开始处理请求.....")
	var req module.UpdateVsysRequest
	//提取 body
	if !decodeJSON(g, &req) {
		return
	}
	// 校验 body
	if ok, msg := validateUpdateVsys(&req); !ok {
		respond400(g, msg)
		return
	}
	id := g.Query("id")
	logrus.Infof("Update_Vsys URL参数 id=%s", id)
	// 业务逻辑
	idInt, _ := strconv.Atoi(id)
	p, err := data.GetVsysByID(idInt)
	if err != nil || p == nil {
		g.JSON(400, module.UpdateVsysResponse{
			Code:    400,
			Message: fmt.Sprintf("没有ID为%d的虚拟系统", idInt),
		})
		return
	}
	p.Description = req.Description
	p.Interfaces = req.Interfaces
	p.UpdatedAt = time.Now()

	if err := data.UpdateVsys(p); err != nil {
		g.JSON(500, module.UpdateVsysResponse{
			Code:    500,
			Message: "数据库更新失败",
		})
		return
	}
	g.JSON(200, module.UpdateVsysResponse{
		Code:    200,
		Message: "更新成功",
	})
}

// 查询虚拟系统列表
func List_Vsys(g *gin.Context) {
	logrus.Info("List_Vsys开始处理请求.....")
	var req module.ListVsysRequest
	// 必填参数存在性检查（与值合法性校验区分开）
	if g.Query("pageSize") == "" {
		respond400(g, "页数大小不能为空")
		return
	}
	if g.Query("pageNum") == "" {
		respond400(g, "页码不能为空")
		return
	}
	// 解析查询参数（统一调用）
	parseListVsysQuery(g, &req)
	logrus.Infof("List_Vsys 参数 pageSize=%v pageNum=%v name=%v", req.PageSize, req.PageNum, req.Name)
	//检查存在性
	if ok, msg := validateListVsys(req.PageSize, req.PageNum); !ok {
		respond400(g, msg)
		return
	}
	// 业务逻辑
	list, total, err := data.ListVsys(req.PageSize, req.PageNum, req.Name)
	if err != nil {
		g.JSON(500, module.ListVsysResponse{
			Code:    500,
			Message: "数据库查询失败",
		})
		return
	}
	newList := make([]module.VsysListItem, 0)
	for _, v := range list {
		item := module.VsysListItem{
			Id:          v.ID,
			Name:        v.Name,
			Description: v.Description,
			Interfaces:  v.Interfaces,
			CreatedAt:   v.CreatedAt.Format(dateLayout),
			UpdatedAt:   v.UpdatedAt.Format(dateLayout),
		}
		newList = append(newList, item)
	}
	g.JSON(200, module.ListVsysResponse{
		Code:    200,
		Message: "查询成功",
		Data: struct {
			List        []module.VsysListItem `json:"list"`
			CurrentPage int                   `json:"currentPage"`
			Total       int                   `json:"total"`
		}{
			List:        newList,
			CurrentPage: req.PageNum,
			Total:       int(total),
		},
	})
}

// 查询虚拟系统详情
func Get_Vsys(g *gin.Context) {
	logrus.Info("Get_Vsys开始处理请求.....")
	idStr := g.Query("id")
	if idStr == "" {
		respond400(g, "虚拟系统ID不能为空")
		return
	}
	idInt, _ := strconv.Atoi(idStr)
	if idInt == 0 {
		respond400(g, "虚拟系统ID非法")
		return
	}
	p, err := data.GetVsysByID(idInt)
	if err != nil || p == nil {
		g.JSON(404, gin.H{"code": 404, "message": fmt.Sprintf("没有ID为%d的虚拟系统", idInt)})
		return
	}
	item := module.VsysListItem{
		Id:          p.ID,
		Name:        p.Name,
		Description: p.Description,
		Interfaces:  p.Interfaces,
		CreatedAt:   p.CreatedAt.Format(dateLayout),
		UpdatedAt:   p.UpdatedAt.Format(dateLayout),
	}
	g.JSON(200, module.GetVsysResponse{
		Code:    200,
		Message: "查询成功",
		Data:    item,
	})
}
